#ifndef __YYH__
#define __YYH__


#include <iostream>
/**
 * @file   vector.h
 * @author yyh <yyh@yyh>
 * @date   Thu Oct 14 11:22:45 2021
 * 
 * @brief  vector的头文件
 * 
 * 
 */

template <typename Object>
class   Vector
{
public:
    //构造函数允许使用者自己定义初始大小（默认值为0），然后初始化数据成员，
    // 并令容量比大小稍大一些。这样可以在不改变容量的前提下执行push-backs。
    explicit vector( init initSize = 0)
	:theSize(initSize),theCapacity(initSize + SPARE_CAPACITY)
    { objects = new Object[theCapacity];}
    
    //复制构造函数调用operator=对已有的Vector进行复制
    Vector( const Vector & rhs) : objects(NULL)
    { operator = (rhs);}

    //析构函数回收基本数组的内存空间。
    ~Vector()
    { delete[] objects;}

    //先进行混淆检验，然后释放旧数据，再生成与所复制的Vector同样容量的新数组。
    //在大小被复制后，依次复制数据项。
    const Vector & operator= (const Vector & rhs)
    {
	if (this != &rhs)
    {
	delete[] objects;
	theSize = rhs.size();
	theCapacity = rhs.theCapacity;

	objects = new Object[capacity()];
	for(int k = 0;k < size();k++)
	    objects[k] = rhs.object[k];
    }
    return *this;
    }

    //在对容量进行扩展后，设定数组成员theSize。
    void resize(int newSize)
{
    if(newSize > the Capacity )
	reserve(newSize * 2 + 1);
    theSize = newSize;
	}

    //通过reserve来实现容量的扩展
    void reserve(int newCapacity)
{
    if( newCapacity < theSize)
	return;

    Object *oldArray = objects;

    objects = new Object[newCapacity];
    for( int k = 0;k < theSize;k++)
	objects[k] = oldArray[k];

    theCapacity = newCapacity;

    delete[] oldArray;
}

    //通过检验index是否在0至size（）-1范围内，实现错误检测功能。否则抛出一个异常。
    Object & operator[]( int index)
        { return objects[index];}
    const Objects & operator[](int index) const
        { return objects[index];}

    //检测是否为空
    bool empty() const
        { return size() == 0;}

    int size () const
        { return theSize;}

    int Capacity() const
        { return theCapacity;}


    void push_back( const Object & k)
{
    if(theSize == theCapacity)
	reserve( 2 * theCapacity + 1);
    objects[theSize++] = x;
    
}
    

    void pop_back()
{   theSize --;}


    const Object & back () const
{   return objects[theSize - 1];}

    //进行内置类型的iterator与const-iterator的声明
    typedef Object * iterator;
    typedef const Object * const_iterator;


    iterator begin()
{   return &objects[0];}

    const_iterator begin() const
{   return &objects[0];}

    iterator end()
{   return &objects[size()];}

    const_iterator end() const
{   return &objects[size()];}

enum{SPARE_CAPACITY = 16};

private:
    //Vector 将其作为数据成员来存储大小容量和基本数组。
    int theSize;
    int theCapacity;
    Object * objects;
};

#else
//do nothing
#endif
